// 前端API统一管理
const API_BASE = '/dishes/api'; // 使用路径代理

// 创建axios实例
const api = axios.create({
    baseURL: API_BASE,
    timeout: 10000,
    headers: {
        'Content-Type': 'application/json'
    }
});

// 请求拦截器
api.interceptors.request.use(
    config => {
        console.log('发送请求:', config.method, config.url, config.data);
        return config;
    },
    error => {
        console.error('请求错误:', error);
        return Promise.reject(error);
    }
);

// 响应拦截器 - 统一处理返回结果
api.interceptors.response.use(
    response => {
        const result = response.data;
        console.log('响应结果:', result);
        
        if (result.code === 200) {
            return result.data;
        } else {
            // 业务错误
            const error = new Error(result.message || '请求失败');
            error.code = result.code;
            error.data = result.data;
            return Promise.reject(error);
        }
    },
    error => {
        // 网络错误或服务器错误
        console.error('响应错误:', error);
        const message = error.response ? 
            `服务器错误: ${error.response.status} - ${error.response.statusText}` : 
            '网络连接失败，请检查网络设置';
        
        const customError = new Error(message);
        customError.originalError = error;
        return Promise.reject(customError);
    }
);

// API接口定义
const API = {
    // 分类相关
    category: {
        // 获取所有分类
        getAll: () => api.get('/categories'),
        // 根据父级ID获取分类
        getByParentId: (parentId) => api.get(`/categories/parent/${parentId}`),
        // 根据ID获取分类
        getById: (id) => api.get(`/categories/${id}`)
    },
    
    // 餐品相关
    product: {
        // 获取所有餐品
        getAll: () => api.get('/products'),
        // 根据分类ID获取餐品
        getByCategoryId: (categoryId) => api.get(`/products/category/${categoryId}`),
        // 根据ID获取餐品
        getById: (id) => api.get(`/products/${id}`)
    },
    
    // 订单相关
    order: {
        // 创建订单
        create: (orderData) => api.post('/orders', orderData),
        // 根据ID获取订单
        getById: (id) => api.get(`/orders/${id}`),
        // 处理订单
        process: (id, processData) => api.put(`/orders/${id}/process`, processData)
    }
};

// 全局错误处理函数
function handleApiError(error, defaultMessage = '操作失败') {
    let message = defaultMessage;
    
    if (error.code) {
        // 业务错误
        message = error.message || defaultMessage;
    } else if (error.response) {
        // HTTP错误
        message = `请求失败: ${error.response.status}`;
    } else if (error.request) {
        // 网络错误
        message = '网络连接失败，请检查网络设置';
    }
    
    // 显示错误提示（需要Element UI）
    if (typeof ELEMENT !== 'undefined' && ELEMENT.Message) {
        ELEMENT.Message.error(message);
    } else {
        alert(message);
    }
    
    console.error('API错误详情:', error);
    return message;
}

// 工具函数：显示成功提示
function showSuccess(message) {
    if (typeof ELEMENT !== 'undefined' && ELEMENT.Message) {
        ELEMENT.Message.success(message);
    } else {
        alert(message);
    }
}

// 工具函数：显示加载中
function showLoading(text = '加载中...') {
    if (typeof ELEMENT !== 'undefined' && ELEMENT.Loading) {
        return ELEMENT.Loading.service({
            lock: true,
            text: text,
            background: 'rgba(0, 0, 0, 0.7)'
        });
    }
    return null;
}

// 工具函数：隐藏加载中
function hideLoading(loadingInstance) {
    if (loadingInstance && typeof loadingInstance.close === 'function') {
        loadingInstance.close();
    }
}
// 工具函数：显示确认对话框
function showConfirm(message, title = '提示') {
    return new Promise((resolve) => {
        if (typeof ELEMENT !== 'undefined' && ELEMENT.MessageBox) {
            ELEMENT.MessageBox.confirm(message, title, {
                confirmButtonText: '确定',
                cancelButtonText: '取消',
                type: 'warning'
            }).then(() => {
                resolve(true);
            }).catch(() => {
                resolve(false);
            });
        } else {
            const result = confirm(message);
            resolve(result);
        }
    });
}

// 工具函数：显示消息提示
function showMessage(message, type = 'info') {
    if (typeof ELEMENT !== 'undefined' && ELEMENT.Message) {
        ELEMENT.Message({
            message: message,
            type: type,
            duration: 3000
        });
    } else {
        alert(message);
    }
}

// 导出新的工具函数
window.showConfirm = showConfirm;
window.showMessage = showMessage;
// 导出到全局作用域
window.API = API;
window.handleApiError = handleApiError;
window.showSuccess = showSuccess;
window.showLoading = showLoading;
window.hideLoading = hideLoading;